home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / termUploadQueue.c < prev    next >
C/C++ Source or Header  |  1995-09-28  |  31KB  |  1,497 lines
  1. /*
  2. **    termUploadQueue.c
  3. **
  4. **    Upload queue user interface.
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_LIST=1000,GAD_NAME,
  13.         GAD_ADD,GAD_REMOVE,GAD_CLEAR,GAD_HIDE,
  14.         GAD_ADD_FILES
  15.     };
  16.  
  17. enum    {    APP_ICON=1,APP_WINDOW=2 };
  18.  
  19. enum    {    TRANSFERMSG_GET_LIST=1,TRANSFERMSG_CHECK_LIST,
  20.         TRANSFERMSG_UPLOAD,TRANSFERMSG_TOGGLE_ICON
  21.     };
  22.  
  23. STATIC struct List    *TransferList;
  24. STATIC struct Node    *TransferNode;
  25. STATIC LONG         TransferOffset,
  26.              TransferCount,
  27.              TransferSignal;
  28. STATIC struct MsgQueue    *TransferQueue;
  29.  
  30.     /* QueuePanel(struct Window *Window):
  31.      *
  32.      *    Create the user interface for the queue panel.
  33.      */
  34.  
  35. STATIC LayoutHandle *
  36. QueuePanel(struct Window *Window)
  37. {
  38.     LayoutHandle *Handle;
  39.  
  40.     TransferNode    = NULL;
  41.     TransferOffset    = -1;
  42.     TransferCount    = GetListSize(TransferList);
  43.  
  44.     if(Handle = LT_CreateHandleTags(Window ? Window -> WScreen : NULL,
  45.         LH_LocaleHook,    &LocaleHook,
  46.     TAG_DONE))
  47.     {
  48.         LT_New(Handle,
  49.             LA_Type,    VERTICAL_KIND,
  50.         TAG_DONE);
  51.         {
  52.             LT_New(Handle,
  53.                 LA_Type,    VERTICAL_KIND,
  54.             TAG_DONE);
  55.             {
  56.                 LT_New(Handle,
  57.                     LA_Type,    LISTVIEW_KIND,
  58.                     LA_LabelID,    MSG_UPLOADQUEUE_FILES_TO_UPLOAD_TXT,
  59.                     LA_LabelPlace,    PLACE_ABOVE,
  60.                     LA_Chars,    30,
  61.                     LA_Lines,    10,
  62.                     LA_ID,        GAD_LIST,
  63.                     LALV_CursorKey,    TRUE,
  64.                     LALV_MaxGrowY,    20,
  65.                     LALV_MaxGrowX,    50,
  66.                     LALV_ResizeX,    TRUE,
  67.                     LALV_ResizeY,    TRUE,
  68.                     GTLV_Labels,    TransferList,
  69.  
  70.                     Kick30 ? LALV_Link : TAG_IGNORE,NIL_LINK,
  71.                 TAG_DONE);
  72.  
  73.                 LT_New(Handle,
  74.                     LA_Type,    STRING_KIND,
  75.                     LA_ID,        GAD_NAME,
  76.                     GTST_MaxChars,    255,
  77.                     LAST_Picker,    TRUE,
  78.                 TAG_DONE);
  79.  
  80.                 LT_EndGroup(Handle);
  81.             }
  82.  
  83.             LT_New(Handle,
  84.                 LA_Type,    HORIZONTAL_KIND,
  85.                 LA_LabelID,    MSG_V36_0043,
  86.                 LA_SameSize,    TRUE,
  87.             TAG_DONE);
  88.             {
  89.                 LT_New(Handle,
  90.                     LA_Type,    BUTTON_KIND,
  91.                     LA_LabelID,    MSG_ADD_SEVERAL_FILES_TXT,
  92.                     LA_ID,        GAD_ADD_FILES,
  93.                 TAG_DONE);
  94.  
  95.                 LT_New(Handle,
  96.                     LA_Type,    BUTTON_KIND,
  97.                     LA_LabelID,    MSG_UPLOADQUEUE_ADD_TXT,
  98.                     LA_ID,        GAD_ADD,
  99.                 TAG_DONE);
  100.  
  101.                 LT_New(Handle,
  102.                     LA_Type,    BUTTON_KIND,
  103.                     LA_LabelID,    MSG_UPLOADQUEUE_REMOVE_TXT,
  104.                     LA_ID,        GAD_REMOVE,
  105.                     GA_Disabled,    TRUE,
  106.                 TAG_DONE);
  107.  
  108.                 LT_New(Handle,
  109.                     LA_Type,    BUTTON_KIND,
  110.                     LA_LabelID,    MSG_UPLOADQUEUE_CLEAR_TXT,
  111.                     LA_ID,        GAD_CLEAR,
  112.                     GA_Disabled,    !TransferCount,
  113.                 TAG_DONE);
  114.  
  115.                 LT_EndGroup(Handle);
  116.             }
  117.  
  118.             LT_New(Handle,
  119.                 LA_Type,    VERTICAL_KIND,
  120.             TAG_DONE);
  121.             {
  122.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  123.  
  124.                 LT_EndGroup(Handle);
  125.             }
  126.  
  127.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  128.                 LAGR_SameSize,    TRUE,
  129.                 LAGR_Spread,    TRUE,
  130.             TAG_DONE);
  131.             {
  132.                 LT_New(Handle,
  133.                     LA_Type,    BUTTON_KIND,
  134.                     LA_LabelID,    MSG_UPLOADQUEUE_BINARY_UPLOAD_TXT,
  135.                     LA_ID,        UPLOAD_BINARY,
  136.                     LABT_ExtraFat,    TRUE,
  137.                     LABT_ReturnKey,    TRUE,
  138.                     GA_Disabled,    !TransferCount,
  139.                 TAG_DONE);
  140.  
  141.                 LT_New(Handle,
  142.                     LA_Type,    BUTTON_KIND,
  143.                     LA_LabelID,    MSG_UPLOADQUEUE_TEXT_UPLOAD_TXT,
  144.                     LA_ID,        UPLOAD_TEXT,
  145.                     GA_Disabled,    !TransferCount,
  146.                 TAG_DONE);
  147.  
  148.                 LT_New(Handle,
  149.                     LA_Type,    BUTTON_KIND,
  150.                     LA_LabelID,    MSG_UPLOADQUEUE_HIDE_TXT,
  151.                     LA_ID,        GAD_HIDE,
  152.                     LABT_EscKey,    TRUE,
  153.                 TAG_DONE);
  154.  
  155.                 LT_EndGroup(Handle);
  156.             }
  157.  
  158.             LT_EndGroup(Handle);
  159.         }
  160.  
  161.         if(LT_Build(Handle,
  162.             LAWN_TitleID,        MSG_UPLOADQUEUE_FILE_UPLOAD_LIST_TXT,
  163.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  164.             LAWN_BelowMouse,    TRUE,
  165.             WA_DepthGadget,        TRUE,
  166.             WA_CloseGadget,        TRUE,
  167.             WA_DragBar,        TRUE,
  168.             WA_RMBTrap,        TRUE,
  169.             WA_Activate,        TRUE,
  170.             WA_SimpleRefresh,    TRUE,
  171.         TAG_DONE))
  172.         {
  173.             GuideContext(CONTEXT_UPLOAD_QUEUE);
  174.  
  175.             return(Handle);
  176.         }
  177.  
  178.         LT_DeleteHandle(Handle);
  179.     }
  180.  
  181.     return(NULL);
  182. }
  183.  
  184.     /* HandleQueueWindow(LayoutHandle *Handle):
  185.      *
  186.      *    Process queue panel messages.
  187.      */
  188.  
  189. STATIC LONG __regargs
  190. HandleQueueWindow(LayoutHandle *Handle)
  191. {
  192.     struct IntuiMessage    *Message;
  193.     ULONG             MsgClass;
  194.     UWORD             MsgCode;
  195.     struct Gadget        *MsgGadget;
  196.  
  197.     struct Node        *Node;
  198.  
  199.     struct Window        *Window = Handle -> Window;
  200.     LONG             Result = 0;
  201.  
  202.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  203.                 *DummyChar;
  204.     struct FileRequester    *FileRequest;
  205.     struct TagItem         DimensionTags[5];
  206.  
  207.     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  208.     {
  209.         MsgClass    = Message -> Class;
  210.         MsgCode        = Message -> Code;
  211.         MsgGadget    = (struct Gadget *)Message -> IAddress;
  212.  
  213.         LT_ReplyIMsg(Message);
  214.  
  215.         if(MsgClass == IDCMP_CLOSEWINDOW)
  216.             Result = GAD_HIDE;
  217.  
  218.         if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadget -> GadgetID == GAD_NAME)
  219.         {
  220.             SplitFileName(LT_GetString(Handle,GAD_NAME),&DummyChar,DummyBuffer);
  221.  
  222.             if(FileRequest = GetFile(Window,LocaleString(MSG_UPLOADQUEUE_SELECT_FILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),FALSE))
  223.             {
  224.                 LT_SetAttributes(Handle,GAD_NAME,
  225.                     GTST_String,    DummyBuffer,
  226.                 TAG_DONE);
  227.             }
  228.  
  229.             LT_Activate(Handle,GAD_NAME);
  230.         }
  231.  
  232.         if(MsgClass == IDCMP_GADGETUP)
  233.         {
  234.             switch(MsgGadget -> GadgetID)
  235.             {
  236.                 case GAD_ADD_FILES:
  237.  
  238.                     LT_LockWindow(Window);
  239.  
  240.                     if(!GetCurrentDirName(DummyBuffer,MAX_FILENAME_LENGTH))
  241.                         DummyBuffer[0] = 0;
  242.  
  243.                     if(FileRequest = AllocAslRequestTags(ASL_FileRequest,
  244.                         ASLFR_Window,        Window,
  245.                         ASLFR_TitleText,    LocaleString(MSG_ADD_FILES_TITLE_TXT),
  246.                         ASLFR_Flags1,        FILF_MULTISELECT,
  247.                         ASLFR_PositiveText,    LocaleString(MSG_ADD_GAD),
  248.                         ASLFR_NegativeText,    LocaleString(MSG_DONE_GAD),
  249.                         ASLFR_InitialDrawer,    DummyBuffer,
  250.                         ASLFR_TextAttr,        &UserFont,
  251.                         ASLFR_PrivateIDCMP,    TRUE,
  252.                     TAG_MORE,GetDimensionTags(Window,DimensionTags)))
  253.                     {
  254.                         LONG i;
  255.  
  256.                         LT_SetAttributes(Handle,GAD_LIST,
  257.                             GTLV_Labels,    ~0,
  258.                         TAG_DONE);
  259.  
  260.                         while(AslRequest(FileRequest,NULL))
  261.                         {
  262.                             for(i = 0 ; i < FileRequest -> fr_NumArgs ; i++)
  263.                             {
  264.                                 if(FileRequest -> fr_ArgList[i] . wa_Lock)
  265.                                 {
  266.                                     if(!NameFromLock(FileRequest -> fr_ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  267.                                         DummyBuffer[0] = 0;
  268.                                 }
  269.                                 else
  270.                                     strcpy(DummyBuffer,FileRequest -> fr_Drawer);
  271.  
  272.                                 if(FileRequest -> fr_ArgList[i] . wa_Name)
  273.                                 {
  274.                                     if(!AddPart(DummyBuffer,FileRequest -> fr_ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  275.                                         DummyBuffer[0] = 0;
  276.                                 }
  277.  
  278.                                 if(DummyBuffer[0])
  279.                                 {
  280.                                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  281.                                     {
  282.                                         Node -> ln_Name = (STRPTR)(Node + 1);
  283.  
  284.                                         strcpy(Node -> ln_Name,DummyBuffer);
  285.  
  286.                                         AddTail(TransferList,Node);
  287.  
  288.                                         TransferNode = Node;
  289.                                         TransferOffset = TransferCount++;
  290.                                     }
  291.                                 }
  292.                             }
  293.  
  294.                             LT_SetAttributes(Handle,GAD_LIST,
  295.                                 GTLV_Labels,    TransferList,
  296.                                 GTLV_Selected,    TransferOffset,
  297.                             TAG_DONE);
  298.                         }
  299.  
  300.                         LT_SetAttributes(Handle,GAD_LIST,
  301.                             GTLV_Labels,    TransferList,
  302.                             GTLV_Selected,    TransferOffset,
  303.                         TAG_DONE);
  304.  
  305.                         if(TransferCount)
  306.                         {
  307.                             LT_SetAttributes(Handle,GAD_NAME,
  308.                                 GTST_String,    "",
  309.                             TAG_DONE);
  310.  
  311.                             LT_SetAttributes(Handle,GAD_REMOVE,
  312.                                 GA_Disabled,    FALSE,
  313.                             TAG_DONE);
  314.  
  315.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  316.                                 GA_Disabled,    FALSE,
  317.                             TAG_DONE);
  318.  
  319.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  320.                                 GA_Disabled,    FALSE,
  321.                             TAG_DONE);
  322.  
  323.                             LT_SetAttributes(Handle,GAD_CLEAR,
  324.                                 GA_Disabled,    FALSE,
  325.                             TAG_DONE);
  326.                         }
  327.  
  328.                         PutDimensionTags(Window,FileRequest -> fr_LeftEdge,FileRequest -> fr_TopEdge,FileRequest -> fr_Width,FileRequest -> fr_Height);
  329.  
  330.                         FreeAslRequest(FileRequest);
  331.                     }
  332.  
  333.                     LT_UnlockWindow(Window);
  334.                     break;
  335.  
  336.                 case GAD_ADD:
  337.  
  338.                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  339.                     {
  340.                         Node -> ln_Name = (STRPTR)(Node + 1);
  341.  
  342.                         Node -> ln_Name[0] = 0;
  343.  
  344.                         LT_SetAttributes(Handle,GAD_LIST,
  345.                             GTLV_Labels,    ~0,
  346.                         TAG_DONE);
  347.  
  348.                         AddTail(TransferList,Node);
  349.  
  350.                         LT_SetAttributes(Handle,GAD_LIST,
  351.                             GTLV_Labels,    TransferList,
  352.                             GTLV_Selected,    TransferOffset = TransferCount++,
  353.                         TAG_DONE);
  354.  
  355.                         LT_SetAttributes(Handle,GAD_NAME,
  356.                             GTST_String,    "",
  357.                         TAG_DONE);
  358.  
  359.                         LT_SetAttributes(Handle,GAD_REMOVE,
  360.                             GA_Disabled,    FALSE,
  361.                         TAG_DONE);
  362.  
  363.                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  364.                             GA_Disabled,    FALSE,
  365.                         TAG_DONE);
  366.  
  367.                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  368.                             GA_Disabled,    FALSE,
  369.                         TAG_DONE);
  370.  
  371.                         LT_SetAttributes(Handle,GAD_CLEAR,
  372.                             GA_Disabled,    FALSE,
  373.                         TAG_DONE);
  374.  
  375.                         TransferNode = Node;
  376.  
  377.                         LT_Activate(Handle,GAD_NAME);
  378.                     }
  379.                     else
  380.                         DisplayBeep(Window -> WScreen);
  381.  
  382.                     break;
  383.  
  384.                 case GAD_REMOVE:
  385.  
  386.                     if(TransferNode)
  387.                     {
  388.                         LT_SetAttributes(Handle,GAD_LIST,
  389.                             GTLV_Labels,    ~0,
  390.                         TAG_DONE);
  391.  
  392.                         if(--TransferCount)
  393.                         {
  394.                             if(TransferNode -> ln_Succ -> ln_Succ)
  395.                                 Node = TransferNode -> ln_Succ;
  396.                             else
  397.                             {
  398.                                 if(TransferNode -> ln_Pred -> ln_Pred)
  399.                                 {
  400.                                     Node = TransferNode -> ln_Pred;
  401.  
  402.                                     TransferOffset--;
  403.                                 }
  404.                                 else
  405.                                 {
  406.                                     TransferOffset = -1;
  407.  
  408.                                     Node = NULL;
  409.                                 }
  410.                             }
  411.                         }
  412.                         else
  413.                         {
  414.                             TransferOffset = -1;
  415.  
  416.                             Node = NULL;
  417.                         }
  418.  
  419.                         Remove(TransferNode);
  420.  
  421.                         FreeVecPooled(TransferNode);
  422.  
  423.                         TransferNode = Node;
  424.  
  425.                         LT_SetAttributes(Handle,GAD_LIST,
  426.                             GTLV_Labels,    TransferList,
  427.                             GTLV_Selected,    TransferOffset,
  428.                         TAG_DONE);
  429.  
  430.                         if(!TransferCount)
  431.                         {
  432.                             LT_SetAttributes(Handle,GAD_REMOVE,
  433.                                 GA_Disabled,    TRUE,
  434.                             TAG_DONE);
  435.  
  436.                             LT_SetAttributes(Handle,GAD_NAME,
  437.                                 GTST_String,    "",
  438.                             TAG_DONE);
  439.  
  440.                             LT_SetAttributes(Handle,GAD_CLEAR,
  441.                                 GA_Disabled,    TRUE,
  442.                             TAG_DONE);
  443.  
  444.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  445.                                 GA_Disabled,    TRUE,
  446.                             TAG_DONE);
  447.  
  448.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  449.                                 GA_Disabled,    TRUE,
  450.                             TAG_DONE);
  451.                         }
  452.                         else
  453.                         {
  454.                             LT_SetAttributes(Handle,GAD_NAME,
  455.                                 GTST_String,    TransferNode -> ln_Name,
  456.                             TAG_DONE);
  457.                         }
  458.                     }
  459.  
  460.                     break;
  461.  
  462.                 case GAD_LIST:
  463.  
  464.                     if(TransferNode = (struct Node *)GetListNode(MsgCode,TransferList))
  465.                     {
  466.                         TransferOffset = MsgCode;
  467.  
  468.                         LT_SetAttributes(Handle,GAD_NAME,
  469.                             GTST_String,    TransferNode -> ln_Name,
  470.                         TAG_DONE);
  471.  
  472.                         LT_SetAttributes(Handle,GAD_REMOVE,
  473.                             GA_Disabled,    FALSE,
  474.                         TAG_DONE);
  475.                     }
  476.  
  477.                     break;
  478.  
  479.                 case GAD_NAME:
  480.  
  481.                     if(TransferNode)
  482.                     {
  483.                         LT_SetAttributes(Handle,GAD_LIST,
  484.                             GTLV_Labels,    ~0,
  485.                         TAG_DONE);
  486.  
  487.                         strcpy(TransferNode -> ln_Name,LT_GetString(Handle,GAD_NAME));
  488.  
  489.                         LT_SetAttributes(Handle,GAD_LIST,
  490.                             GTLV_Labels,    TransferList,
  491.                             GTLV_Selected,    ~0,
  492.                         TAG_DONE);
  493.                     }
  494.                     else
  495.                     {
  496.                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  497.                         {
  498.                             Node -> ln_Name = (STRPTR)(Node + 1);
  499.  
  500.                             strcpy(Node -> ln_Name,LT_GetString(Handle,GAD_NAME));
  501.  
  502.                             LT_SetAttributes(Handle,GAD_LIST,
  503.                                 GTLV_Labels,    ~0,
  504.                             TAG_DONE);
  505.  
  506.                             AddTail(TransferList,Node);
  507.  
  508.                             TransferCount++;
  509.  
  510.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  511.                                 GA_Disabled,    FALSE,
  512.                             TAG_DONE);
  513.  
  514.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  515.                                 GA_Disabled,    FALSE,
  516.                             TAG_DONE);
  517.  
  518.                             LT_SetAttributes(Handle,GAD_CLEAR,
  519.                                 GA_Disabled,    FALSE,
  520.                             TAG_DONE);
  521.  
  522.                             LT_SetAttributes(Handle,GAD_LIST,
  523.                                 GTLV_Labels,        TransferList,
  524.                                 GTLV_Selected,        ~0,
  525.                                 GTLV_MakeVisible,    TransferCount - 1,
  526.                             TAG_DONE);
  527.                         }
  528.                     }
  529.  
  530.                     LT_SetAttributes(Handle,GAD_REMOVE,
  531.                         GA_Disabled,    TRUE,
  532.                     TAG_DONE);
  533.  
  534.                     LT_SetAttributes(Handle,GAD_NAME,
  535.                         GTST_String,    "",
  536.                     TAG_DONE);
  537.  
  538.                     TransferNode    = NULL;
  539.                     TransferOffset    = -1;
  540.  
  541.                     break;
  542.  
  543.                 case GAD_CLEAR:
  544.  
  545.                     LT_SetAttributes(Handle,GAD_LIST,
  546.                         GTLV_Labels,    ~0,
  547.                     TAG_DONE);
  548.  
  549.                     TransferCount    = 0;
  550.                     TransferOffset    = -1;
  551.                     TransferNode    = NULL;
  552.  
  553.                     FreeList(TransferList);
  554.  
  555.                     LT_SetAttributes(Handle,GAD_REMOVE,
  556.                         GA_Disabled,    TRUE,
  557.                     TAG_DONE);
  558.  
  559.                     LT_SetAttributes(Handle,GAD_NAME,
  560.                         GTST_String,    "",
  561.                     TAG_DONE);
  562.  
  563.                     LT_SetAttributes(Handle,GAD_CLEAR,
  564.                         GA_Disabled,    TRUE,
  565.                     TAG_DONE);
  566.  
  567.                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  568.                         GA_Disabled,    TRUE,
  569.                     TAG_DONE);
  570.  
  571.                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  572.                         GA_Disabled,    TRUE,
  573.                     TAG_DONE);
  574.  
  575.                     LT_SetAttributes(Handle,GAD_LIST,
  576.                         GTLV_Labels,    TransferList,
  577.                         GTLV_Selected,    ~0,
  578.                     TAG_DONE);
  579.  
  580.                     break;
  581.  
  582.                 case UPLOAD_BINARY:
  583.                 case UPLOAD_TEXT:
  584.                 case GAD_HIDE:
  585.  
  586.                     Result = MsgGadget -> GadgetID;
  587.                     break;
  588.             }
  589.         }
  590.     }
  591.  
  592.     return(Result);
  593. }
  594.  
  595.     /* QueueClientDestructor(struct DataMsg *Item):
  596.      *
  597.      *    Local msgitem destructor.
  598.      */
  599.  
  600. STATIC VOID __stdargs
  601. QueueClientDestructor(struct DataMsg *Item)
  602. {
  603.     Signal(TransferProcess,1L << TransferSignal);
  604. }
  605.  
  606.     /* QueueEntry(VOID):
  607.      *
  608.      *    The entry point for the queue process.
  609.      */
  610.  
  611. STATIC VOID __saveds
  612. QueueEntry(VOID)
  613. {
  614.     if(TransferList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  615.     {
  616.         if(TransferQueue = CreateMsgQueue(NULL,0))
  617.         {
  618.             struct MsgPort        *AppPort;
  619.             struct AppIcon        *AppIcon;
  620.             struct AppWindow    *AppWindow;
  621.             APTR             OldPtr;
  622.  
  623.             NewList(TransferList);
  624.  
  625.             TransferNode    = NULL;
  626.             TransferOffset    = -1;
  627.  
  628.             if(AppPort = CreateMsgPort())
  629.             {
  630.                 if((TransferSignal = AllocSignal(-1)) != -1)
  631.                 {
  632.                     ULONG             Signals;
  633.                     BOOLEAN             Done = FALSE;
  634.                     LayoutHandle        *Handle;
  635.                     struct Window        *LocalWindow;
  636.                     ULONG             WindowMask,
  637.                                  TransferMask,
  638.                                  ClientMask;
  639.                     struct AppMessage    *AppMessage;
  640.                     struct DiskObject    *LoadedIcon = NULL;
  641.  
  642.                     if(WorkbenchBase && !Config -> TransferConfig -> HideUploadIcon)
  643.                     {
  644.                         if(IconBase)
  645.                         {
  646.                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  647.  
  648.                             strcpy(LocalBuffer,Config -> PathConfig -> DefaultStorage);
  649.  
  650.                             if(AddPart(LocalBuffer,"term_DropIcon",MAX_FILENAME_LENGTH))
  651.                                 LoadedIcon = GetDiskObject(LocalBuffer);
  652.  
  653.                             if(!LoadedIcon)
  654.                                 LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  655.                         }
  656.  
  657.                         AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  658.                     }
  659.                     else
  660.                         AppIcon = NULL;
  661.  
  662.                     AppWindow    = NULL;
  663.                     WindowMask    = NULL;
  664.                     Handle        = NULL;
  665.                     LocalWindow    = NULL;
  666.                     TransferMask    = TransferQueue -> SigMask;
  667.                     ClientMask    = (1L << TransferSignal);
  668.  
  669.                     TransferProcess = (struct Process *)FindTask(NULL);
  670.  
  671.                     OldPtr = TransferProcess -> pr_WindowPtr;
  672.  
  673.                     Signal(ThisProcess,SIG_HANDSHAKE);
  674.  
  675.                     do
  676.                     {
  677.                         Signals = Wait(SIG_KILL | SIG_SHOW | SIG_HIDE | SIG_GOAWAY | WindowMask | TransferMask | PORTMASK(AppPort));
  678.  
  679.                         if(Signals & TransferMask)
  680.                         {
  681.                             struct DataMsg *Item;
  682.  
  683.                             while(Item = GetMsgItem(TransferQueue))
  684.                             {
  685.                                 switch(Item -> Type)
  686.                                 {
  687.                                     case TRANSFERMSG_GET_LIST:
  688.  
  689.                                         Item -> Data = NULL;
  690.  
  691.                                         if(TransferList -> lh_Head -> ln_Succ)
  692.                                         {
  693.                                             struct List *List;
  694.  
  695.                                             if(Handle)
  696.                                             {
  697.                                                 LT_SetAttributes(Handle,GAD_LIST,
  698.                                                     GTLV_Labels,    ~0,
  699.                                                 TAG_DONE);
  700.                                             }
  701.  
  702.                                             if(List = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  703.                                             {
  704.                                                 struct Node *Node,*Next;
  705.  
  706.                                                 NewList(List);
  707.  
  708.                                                 for(Node = TransferList -> lh_Head ; Next = Node -> ln_Succ ; Node = Next)
  709.                                                 {
  710.                                                     Remove(Node);
  711.  
  712.                                                     AddTail(List,Node);
  713.                                                 }
  714.  
  715.                                                 Item -> Data = (UBYTE *)List;
  716.                                             }
  717.  
  718.                                             if(Handle)
  719.                                             {
  720.                                                 TransferCount = GetListSize(TransferList);
  721.  
  722.                                                 TransferOffset    = -1;
  723.                                                 TransferNode    = NULL;
  724.  
  725.                                                 LT_SetAttributes(Handle,GAD_REMOVE,
  726.                                                     GA_Disabled,    TRUE,
  727.                                                 TAG_DONE);
  728.  
  729.                                                 LT_SetAttributes(Handle,GAD_NAME,
  730.                                                     GTST_String,    "",
  731.                                                 TAG_DONE);
  732.  
  733.                                                 LT_SetAttributes(Handle,GAD_CLEAR,
  734.                                                     GA_Disabled,    !TransferCount,
  735.                                                 TAG_DONE);
  736.  
  737.                                                 LT_SetAttributes(Handle,UPLOAD_BINARY,
  738.                                                     GA_Disabled,    !TransferCount,
  739.                                                 TAG_DONE);
  740.  
  741.                                                 LT_SetAttributes(Handle,UPLOAD_TEXT,
  742.                                                     GA_Disabled,    !TransferCount,
  743.                                                 TAG_DONE);
  744.  
  745.                                                 LT_SetAttributes(Handle,GAD_LIST,
  746.                                                     GTLV_Labels,    TransferList,
  747.                                                 TAG_DONE);
  748.                                             }
  749.                                         }
  750.  
  751.                                         break;
  752.  
  753.                                         // Check to see if there is anything in the list?
  754.  
  755.                                     case TRANSFERMSG_CHECK_LIST:
  756.  
  757.                                         if(TransferList -> lh_Head -> ln_Succ)
  758.                                             Item -> Size = TRUE;
  759.                                         else
  760.                                             Item -> Size = FALSE;
  761.  
  762.                                         break;
  763.  
  764.                                         // Start a file tansfer?
  765.  
  766.                                     case TRANSFERMSG_UPLOAD:
  767.                                     {
  768.                                         UBYTE        Type = Item -> Size;
  769.                                         struct DataMsg    Msg;
  770.  
  771.                                         DeleteMsgItem(Item);
  772.  
  773.                                         Item = NULL;
  774.  
  775.                                         InitMsgItem(&Msg,QueueClientDestructor);
  776.  
  777.                                         Msg . Type = DATAMSGTYPE_UPLOAD;
  778.                                         Msg . Data = (UBYTE *)TransferList;
  779.                                         Msg . Size = Type;
  780.  
  781.                                         if(Handle)
  782.                                         {
  783.                                             LT_SetAttributes(Handle,GAD_LIST,
  784.                                                 GTLV_Labels,    ~0,
  785.                                             TAG_DONE);
  786.  
  787.                                             LT_LockWindow(LocalWindow);
  788.                                         }
  789.  
  790.                                         Forbid();
  791.  
  792.                                         ClrSignal(ClientMask);
  793.  
  794.                                         PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  795.  
  796.                                         Wait(ClientMask);
  797.  
  798.                                         Permit();
  799.  
  800.                                         if(Handle)
  801.                                         {
  802.                                             TransferCount = GetListSize(TransferList);
  803.  
  804.                                             TransferOffset    = -1;
  805.                                             TransferNode    = NULL;
  806.  
  807.                                             LT_SetAttributes(Handle,GAD_REMOVE,
  808.                                                 GA_Disabled,    TRUE,
  809.                                             TAG_DONE);
  810.  
  811.                                             LT_SetAttributes(Handle,GAD_NAME,
  812.                                                 GTST_String,    "",
  813.                                             TAG_DONE);
  814.  
  815.                                             LT_SetAttributes(Handle,GAD_CLEAR,
  816.                                                 GA_Disabled,    !TransferCount,
  817.                                             TAG_DONE);
  818.  
  819.                                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  820.                                                 GA_Disabled,    !TransferCount,
  821.                                             TAG_DONE);
  822.  
  823.                                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  824.                                                 GA_Disabled,    !TransferCount,
  825.                                             TAG_DONE);
  826.  
  827.                                             LT_SetAttributes(Handle,GAD_LIST,
  828.                                                 GTLV_Labels,    TransferList,
  829.                                             TAG_DONE);
  830.  
  831.                                             LT_UnlockWindow(LocalWindow);
  832.                                         }
  833.  
  834.                                         break;
  835.                                     }
  836.  
  837.                                         // Show or hide the icon?
  838.  
  839.                                     case TRANSFERMSG_TOGGLE_ICON:
  840.  
  841.                                             // Hide the icon
  842.  
  843.                                         if(Item -> Size)
  844.                                         {
  845.                                             if(AppIcon)
  846.                                             {
  847.                                                 RemoveAppIcon(AppIcon);
  848.  
  849.                                                 AppIcon = NULL;
  850.                                             }
  851.  
  852.                                             if(LoadedIcon)
  853.                                             {
  854.                                                 FreeDiskObject(LoadedIcon);
  855.  
  856.                                                 LoadedIcon = NULL;
  857.                                             }
  858.                                         }
  859.                                         else
  860.                                         {
  861.                                             if(!AppIcon)
  862.                                             {
  863.                                                 if(WorkbenchBase)
  864.                                                 {
  865.                                                     if(IconBase)
  866.                                                     {
  867.                                                         UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  868.  
  869.                                                         strcpy(LocalBuffer,Config -> PathConfig -> DefaultStorage);
  870.  
  871.                                                         if(AddPart(LocalBuffer,"term_DropIcon",MAX_FILENAME_LENGTH))
  872.                                                             LoadedIcon = GetDiskObject(LocalBuffer);
  873.  
  874.                                                         if(!LoadedIcon)
  875.                                                             LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  876.                                                     }
  877.  
  878.                                                     AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  879.                                                 }
  880.                                                 else
  881.                                                     AppIcon = NULL;
  882.                                             }
  883.                                         }
  884.  
  885.                                         break;
  886.                                 }
  887.  
  888.                                 DeleteMsgItem(Item);
  889.                             }
  890.                         }
  891.  
  892.                         if(Signals & SIG_HIDE)
  893.                         {
  894.                             if(AppWindow)
  895.                             {
  896.                                 RemoveAppWindow(AppWindow);
  897.  
  898.                                 AppWindow = NULL;
  899.                             }
  900.  
  901.                             if(Handle)
  902.                             {
  903.                                 LT_DeleteHandle(Handle);
  904.  
  905.                                 Handle = NULL;
  906.                             }
  907.  
  908.                             WindowMask    = NULL;
  909.                             LocalWindow    = NULL;
  910.  
  911.                             TransferProcess -> pr_WindowPtr = OldPtr;
  912.  
  913.                             Signal(ThisProcess,SIG_HANDSHAKE);
  914.                         }
  915.  
  916.                         if(Signals & SIG_GOAWAY)
  917.                         {
  918.                             if(Handle)
  919.                             {
  920.                                 if(LocalWindow -> WScreen == Screen)
  921.                                 {
  922.                                     if(AppWindow)
  923.                                     {
  924.                                         RemoveAppWindow(AppWindow);
  925.  
  926.                                         AppWindow = NULL;
  927.                                     }
  928.  
  929.                                     LT_DeleteHandle(Handle);
  930.  
  931.                                     Handle        = NULL;
  932.                                     WindowMask    = NULL;
  933.                                     LocalWindow    = NULL;
  934.  
  935.                                     TransferProcess -> pr_WindowPtr = OldPtr;
  936.                                 }
  937.                             }
  938.  
  939.                             Signal(ThisProcess,SIG_HANDSHAKE);
  940.                         }
  941.  
  942.                         if(Signals & SIG_KILL)
  943.                             break;
  944.  
  945.                         if(Signals & SIG_SHOW)
  946.                         {
  947.                             if(!Handle)
  948.                             {
  949.                                 Forbid();
  950.  
  951.                                 if(Handle = QueuePanel(Window))
  952.                                 {
  953.                                     Permit();
  954.  
  955.                                     if(WorkbenchBase)
  956.                                         AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  957.                                     else
  958.                                         AppWindow = NULL;
  959.  
  960.                                     LocalWindow    = Handle -> Window;
  961.                                     WindowMask    = PORTMASK(LocalWindow -> UserPort);
  962.  
  963.                                     TransferProcess -> pr_WindowPtr = LocalWindow;
  964.                                 }
  965.                                 else
  966.                                     Permit();
  967.                             }
  968.  
  969.                             if(Handle)
  970.                                 LT_ShowWindow(Handle,TRUE);
  971.                         }
  972.  
  973.                         if(Signals & WindowMask)
  974.                         {
  975.                             struct DataMsg    Msg;
  976.                             LONG        Type;
  977.  
  978.                             switch(Type = HandleQueueWindow(Handle))
  979.                             {
  980.                                 case GAD_HIDE:
  981.  
  982.                                     if(AppWindow)
  983.                                     {
  984.                                         RemoveAppWindow(AppWindow);
  985.  
  986.                                         AppWindow = NULL;
  987.                                     }
  988.  
  989.                                     if(Handle)
  990.                                     {
  991.                                         LT_DeleteHandle(Handle);
  992.  
  993.                                         Handle = NULL;
  994.                                     }
  995.  
  996.                                     TransferProcess -> pr_WindowPtr = OldPtr;
  997.  
  998.                                     WindowMask    = NULL;
  999.                                     LocalWindow    = NULL;
  1000.  
  1001.                                     break;
  1002.  
  1003.                                 case UPLOAD_BINARY:
  1004.                                 case UPLOAD_TEXT:
  1005.  
  1006.                                     InitMsgItem(&Msg,QueueClientDestructor);
  1007.  
  1008.                                     Msg . Type = DATAMSGTYPE_UPLOAD;
  1009.                                     Msg . Data = (UBYTE *)TransferList;
  1010.                                     Msg . Size = Type;
  1011.  
  1012.                                     if(Handle)
  1013.                                     {
  1014.                                         LT_SetAttributes(Handle,GAD_LIST,
  1015.                                             GTLV_Labels,    ~0,
  1016.                                         TAG_DONE);
  1017.  
  1018.                                         LT_LockWindow(LocalWindow);
  1019.                                     }
  1020.  
  1021.                                     Forbid();
  1022.  
  1023.                                     ClrSignal(ClientMask);
  1024.  
  1025.                                     PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  1026.  
  1027.                                     Wait(ClientMask);
  1028.  
  1029.                                     Permit();
  1030.  
  1031.                                     if(Handle)
  1032.                                     {
  1033.                                         TransferCount = GetListSize(TransferList);
  1034.  
  1035.                                         TransferOffset    = -1;
  1036.                                         TransferNode    = NULL;
  1037.  
  1038.                                         LT_SetAttributes(Handle,GAD_REMOVE,
  1039.                                             GA_Disabled,    TRUE,
  1040.                                         TAG_DONE);
  1041.  
  1042.                                         LT_SetAttributes(Handle,GAD_NAME,
  1043.                                             GTST_String,    "",
  1044.                                         TAG_DONE);
  1045.  
  1046.                                         LT_SetAttributes(Handle,GAD_CLEAR,
  1047.                                             GA_Disabled,    !TransferCount,
  1048.                                         TAG_DONE);
  1049.  
  1050.                                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  1051.                                             GA_Disabled,    !TransferCount,
  1052.                                         TAG_DONE);
  1053.  
  1054.                                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  1055.                                             GA_Disabled,    !TransferCount,
  1056.                                         TAG_DONE);
  1057.  
  1058.                                         LT_SetAttributes(Handle,GAD_LIST,
  1059.                                             GTLV_Labels,    TransferList,
  1060.                                         TAG_DONE);
  1061.  
  1062.                                         LT_UnlockWindow(LocalWindow);
  1063.                                     }
  1064.  
  1065.                                     break;
  1066.                             }
  1067.                         }
  1068.  
  1069.                         if(Signals & PORTMASK(AppPort))
  1070.                         {
  1071.                             while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1072.                             {
  1073.                                 if(AppMessage -> am_Type == AMTYPE_APPWINDOW && Handle)
  1074.                                 {
  1075.                                     UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1076.                                     BPTR    OldDir,FileLock;
  1077.                                     LONG    i;
  1078.  
  1079.                                     TransferProcess -> pr_WindowPtr = (APTR)-1;
  1080.  
  1081.                                     LT_SetAttributes(Handle,GAD_LIST,
  1082.                                         GTLV_Labels,    ~0,
  1083.                                     TAG_DONE);
  1084.  
  1085.                                     for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1086.                                     {
  1087.                                         if(AppMessage -> am_ArgList[i] . wa_Name)
  1088.                                         {
  1089.                                             OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1090.  
  1091.                                             if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1092.                                             {
  1093.                                                 if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1094.                                                 {
  1095.                                                     if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1096.                                                     {
  1097.                                                         struct Node *Node;
  1098.  
  1099.                                                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1100.                                                         {
  1101.                                                             Node -> ln_Name = (STRPTR)(Node + 1);
  1102.  
  1103.                                                             strcpy(Node -> ln_Name,DummyBuffer);
  1104.  
  1105.                                                             AddTail(TransferList,Node);
  1106.  
  1107.                                                             TransferCount++;
  1108.                                                         }
  1109.                                                     }
  1110.  
  1111.                                                     UnLock(FileLock);
  1112.                                                 }
  1113.                                             }
  1114.  
  1115.                                             CurrentDir(OldDir);
  1116.                                         }
  1117.                                     }
  1118.  
  1119.                                     TransferProcess -> pr_WindowPtr = LocalWindow;
  1120.  
  1121.                                     LT_SetAttributes(Handle,GAD_LIST,
  1122.                                         GTLV_Labels,    TransferList,
  1123.                                     TAG_DONE);
  1124.  
  1125.                                     LT_SetAttributes(Handle,GAD_CLEAR,
  1126.                                         GA_Disabled,    !TransferCount,
  1127.                                     TAG_DONE);
  1128.  
  1129.                                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  1130.                                         GA_Disabled,    !TransferCount,
  1131.                                     TAG_DONE);
  1132.  
  1133.                                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  1134.                                         GA_Disabled,    !TransferCount,
  1135.                                     TAG_DONE);
  1136.                                 }
  1137.  
  1138.                                 if(AppMessage -> am_Type == AMTYPE_APPICON)
  1139.                                 {
  1140.                                     if(AppMessage -> am_NumArgs)
  1141.                                     {
  1142.                                         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1143.                                         BPTR    OldDir,FileLock;
  1144.                                         LONG    i;
  1145.  
  1146.                                         TransferProcess -> pr_WindowPtr = (APTR)-1;
  1147.  
  1148.                                         if(Handle)
  1149.                                         {
  1150.                                             LT_SetAttributes(Handle,GAD_LIST,
  1151.                                                 GTLV_Labels,    ~0,
  1152.                                             TAG_DONE);
  1153.                                         }
  1154.  
  1155.                                         for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1156.                                         {
  1157.                                             if(AppMessage -> am_ArgList[i] . wa_Name)
  1158.                                             {
  1159.                                                 OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1160.  
  1161.                                                 if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1162.                                                 {
  1163.                                                     if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1164.                                                     {
  1165.                                                         if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1166.                                                         {
  1167.                                                             struct Node *Node;
  1168.  
  1169.                                                             if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1170.                                                             {
  1171.                                                                 Node -> ln_Name = (STRPTR)(Node + 1);
  1172.  
  1173.                                                                 strcpy(Node -> ln_Name,DummyBuffer);
  1174.  
  1175.                                                                 AddTail(TransferList,Node);
  1176.  
  1177.                                                                 TransferCount++;
  1178.                                                             }
  1179.                                                         }
  1180.  
  1181.                                                         UnLock(FileLock);
  1182.                                                     }
  1183.                                                 }
  1184.  
  1185.                                                 CurrentDir(OldDir);
  1186.                                             }
  1187.                                         }
  1188.  
  1189.                                         if(Handle)
  1190.                                         {
  1191.                                             TransferProcess -> pr_WindowPtr = LocalWindow;
  1192.  
  1193.                                             LT_SetAttributes(Handle,GAD_LIST,
  1194.                                                 GTLV_Labels,    TransferList,
  1195.                                             TAG_DONE);
  1196.  
  1197.                                             LT_SetAttributes(Handle,GAD_CLEAR,
  1198.                                                 GA_Disabled,    !TransferCount,
  1199.                                             TAG_DONE);
  1200.  
  1201.                                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  1202.                                                 GA_Disabled,    !TransferCount,
  1203.                                             TAG_DONE);
  1204.  
  1205.                                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  1206.                                                 GA_Disabled,    !TransferCount,
  1207.                                             TAG_DONE);
  1208.                                         }
  1209.                                         else
  1210.                                             TransferProcess -> pr_WindowPtr = OldPtr;
  1211.                                     }
  1212.                                     else
  1213.                                     {
  1214.                                         if(!Handle)
  1215.                                         {
  1216.                                             if(Handle = QueuePanel(NULL))
  1217.                                             {
  1218.                                                 AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  1219.  
  1220.                                                 LocalWindow = Handle -> Window;
  1221.  
  1222.                                                 WindowMask = PORTMASK(LocalWindow -> UserPort);
  1223.  
  1224.                                                 TransferProcess -> pr_WindowPtr = LocalWindow;
  1225.                                             }
  1226.                                         }
  1227.                                     }
  1228.                                 }
  1229.  
  1230.                                 ReplyMsg(AppMessage);
  1231.                             }
  1232.                         }
  1233.                     }
  1234.                     while(!Done);
  1235.  
  1236.                     if(AppIcon)
  1237.                         RemoveAppIcon(AppIcon);
  1238.  
  1239.                     if(AppWindow)
  1240.                         RemoveAppWindow(AppWindow);
  1241.  
  1242.                     if(LoadedIcon)
  1243.                         FreeDiskObject(LoadedIcon);
  1244.  
  1245.                     if(Handle)
  1246.                         LT_DeleteHandle(Handle);
  1247.  
  1248.                     while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1249.                         ReplyMsg(AppMessage);
  1250.  
  1251.                     FreeSignal(TransferSignal);
  1252.                 }
  1253.             }
  1254.  
  1255.             DeleteMsgQueue(TransferQueue);
  1256.         }
  1257.  
  1258.         DeleteList(TransferList);
  1259.  
  1260.         TransferList = NULL;
  1261.     }
  1262.  
  1263.     Forbid();
  1264.  
  1265.     TransferProcess = NULL;
  1266.  
  1267.     Signal(ThisProcess,SIG_HANDSHAKE);
  1268. }
  1269.  
  1270.     /* CloseQueueWindow():
  1271.      *
  1272.      *    Close the queue window, wherever it may be.
  1273.      */
  1274.  
  1275. VOID
  1276. CloseQueueWindow()
  1277. {
  1278.     if(TransferProcess)
  1279.     {
  1280.         Forbid();
  1281.  
  1282.         ClrSignal(SIG_HANDSHAKE);
  1283.  
  1284.         Signal(TransferProcess,SIG_GOAWAY);
  1285.  
  1286.         Wait(SIG_HANDSHAKE);
  1287.  
  1288.         Permit();
  1289.     }
  1290. }
  1291.  
  1292.     /* DeleteQueueProcess():
  1293.      *
  1294.      *    Terminate the queue handler process.
  1295.      */
  1296.  
  1297. VOID
  1298. DeleteQueueProcess()
  1299. {
  1300.     if(TransferProcess)
  1301.     {
  1302.         Forbid();
  1303.  
  1304.         ClrSignal(SIG_HANDSHAKE);
  1305.  
  1306.         Signal(TransferProcess,SIG_KILL);
  1307.  
  1308.         Wait(SIG_HANDSHAKE);
  1309.  
  1310.         Permit();
  1311.     }
  1312. }
  1313.  
  1314.     /* CreateQueueProcess():
  1315.      *
  1316.      *    Create the queue handler process, if it's still around
  1317.      *    bring it to the front.
  1318.      */
  1319.  
  1320. BOOLEAN
  1321. CreateQueueProcess()
  1322. {
  1323.     if(!TransferProcess)
  1324.     {
  1325.         Forbid();
  1326.  
  1327.         if(CreateNewProcTags(
  1328.             NP_Entry,    QueueEntry,
  1329.             NP_Name,    "term Upload process",
  1330.             NP_Priority,    SysBase -> ThisTask -> tc_Node . ln_Pri,
  1331.             NP_StackSize,    6144,
  1332.             NP_WindowPtr,    NULL,
  1333.         TAG_DONE))
  1334.         {
  1335.             ClrSignal(SIG_HANDSHAKE);
  1336.  
  1337.             Wait(SIG_HANDSHAKE);
  1338.         }
  1339.  
  1340.         Permit();
  1341.     }
  1342.     else
  1343.         Signal(TransferProcess,SIG_SHOW);
  1344.  
  1345.     return((BOOLEAN)(TransferProcess != NULL));
  1346. }
  1347.  
  1348. STATIC VOID __stdargs
  1349. LocalMsgDestructor(struct DataMsg *Item)
  1350. {
  1351.     Signal(Item -> Client,Item -> Mask);
  1352. }
  1353.  
  1354.     /* GetUploadList():
  1355.      *
  1356.      *    Copy the current upload list and return it.
  1357.      */
  1358.  
  1359. struct List *
  1360. GetUploadList()
  1361. {
  1362.     if(TransferProcess)
  1363.     {
  1364.         BYTE SigBit;
  1365.  
  1366.         if((SigBit = AllocSignal(-1)) != -1)
  1367.         {
  1368.             struct DataMsg Msg;
  1369.  
  1370.             InitMsgItem(&Msg,LocalMsgDestructor);
  1371.  
  1372.             Msg . Type    = TRANSFERMSG_GET_LIST;
  1373.             Msg . Client    = SysBase -> ThisTask;
  1374.             Msg . Mask    = 1L << SigBit;
  1375.  
  1376.             ClrSignal(Msg . Mask);
  1377.  
  1378.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1379.  
  1380.             Wait(Msg . Mask);
  1381.  
  1382.             FreeSignal(SigBit);
  1383.  
  1384.             return((struct List *)Msg . Data);
  1385.         }
  1386.     }
  1387.  
  1388.     return(NULL);
  1389. }
  1390.  
  1391.     /* CheckUpload():
  1392.      *
  1393.      *    Check if there is anything in the upload list.
  1394.      */
  1395.  
  1396. BOOLEAN
  1397. CheckUpload()
  1398. {
  1399.     if(TransferProcess)
  1400.     {
  1401.         BYTE SigBit;
  1402.  
  1403.         if((SigBit = AllocSignal(-1)) != -1)
  1404.         {
  1405.             struct DataMsg Msg;
  1406.  
  1407.             InitMsgItem(&Msg,LocalMsgDestructor);
  1408.  
  1409.             Msg . Type    = TRANSFERMSG_CHECK_LIST;
  1410.             Msg . Client    = SysBase -> ThisTask;
  1411.             Msg . Mask    = 1L << SigBit;
  1412.  
  1413.             ClrSignal(Msg . Mask);
  1414.  
  1415.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1416.  
  1417.             Wait(Msg . Mask);
  1418.  
  1419.             FreeSignal(SigBit);
  1420.  
  1421.             return((BOOLEAN)Msg . Size);
  1422.         }
  1423.     }
  1424.  
  1425.     return(FALSE);
  1426. }
  1427.  
  1428.     /* StartUpload(UBYTE Type):
  1429.      *
  1430.      *    Start an upload the standard way.
  1431.      */
  1432.  
  1433. VOID __regargs
  1434. StartUpload(UBYTE Type)
  1435. {
  1436.     if(TransferProcess)
  1437.     {
  1438.         BYTE SigBit;
  1439.  
  1440.         if((SigBit = AllocSignal(-1)) != -1)
  1441.         {
  1442.             struct DataMsg Msg;
  1443.  
  1444.             SetQueueDiscard(SpecialQueue,FALSE);
  1445.  
  1446.             InitMsgItem(&Msg,LocalMsgDestructor);
  1447.  
  1448.             Msg . Type    = TRANSFERMSG_UPLOAD;
  1449.             Msg . Size    = Type;
  1450.             Msg . Client    = SysBase -> ThisTask;
  1451.             Msg . Mask    = 1L << SigBit;
  1452.  
  1453.             ClrSignal(Msg . Mask);
  1454.  
  1455.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1456.  
  1457.             Wait(Msg . Mask);
  1458.  
  1459.             FreeSignal(SigBit);
  1460.         }
  1461.     }
  1462. }
  1463.  
  1464.     /* ToggleUploadQueueIcon():
  1465.      *
  1466.      *    Turn the upload queue appicon on or off.
  1467.      */
  1468.  
  1469. VOID __regargs
  1470. ToggleUploadQueueIcon(BOOL Mode)
  1471. {
  1472.     if(TransferProcess)
  1473.     {
  1474.         BYTE SigBit;
  1475.  
  1476.         if((SigBit = AllocSignal(-1)) != -1)
  1477.         {
  1478.             struct DataMsg Msg;
  1479.  
  1480.             InitMsgItem(&Msg,LocalMsgDestructor);
  1481.  
  1482.             Msg . Type    = TRANSFERMSG_TOGGLE_ICON;
  1483.             Msg . Size    = Mode;
  1484.             Msg . Client    = SysBase -> ThisTask;
  1485.             Msg . Mask    = 1L << SigBit;
  1486.  
  1487.             ClrSignal(Msg . Mask);
  1488.  
  1489.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1490.  
  1491.             Wait(Msg . Mask);
  1492.  
  1493.             FreeSignal(SigBit);
  1494.         }
  1495.     }
  1496. }
  1497.